VOID barrier_sync(STRING addr, DURATION timeout=0)¶

When writing test cases, the most common pattern is to start a mock server instance, a Varnish instance, and spin up a mock client. Those entities run asynchronously, and others exist like background processes (process) or log readers (logexpect). While you can synchronize with individual entities and wait for their completion, you must use a barrier if you need to synchronize two or more entities, or wait until a certain point instead of completion.

Not only is it possible to synchronize between test entities, with the barrier_sync function you can even synchronize VCL code:

sub vcl_recv {


    # wait for some barrier b1 to complete


    vtc.barrier_sync("${b1_sock}");
}

If the function fails to synchronize with the barrier for some reason, or if it reaches the optional timeout, it fails the VCL transaction.

BACKEND no_backend()¶

Fails at backend selection.

STEVEDORE no_stevedore()¶

Fails at storage selection.

IP no_ip()¶

Returns a null IP address, not even a bogo_ip.

VOID panic(STRING)¶

It can be useful to crash the child process in order to test the robustness of a VMOD.

VOID sleep(DURATION)¶

Block the current worker thread.

VOID workspace_alloc(ENUM, INT size)¶

VOID workspace_alloc(


   ENUM {client, backend, session, thread},


   INT size
)

Allocate and zero out memory from a workspace. A negative size will allocate as much as needed to leave that many bytes free. The actual allocation size may be higher to comply with memory alignment requirements of the CPU architecture. A failed allocation fails the transaction.

BYTES workspace_reserve(ENUM, INT size)¶

BYTES workspace_reserve(


   ENUM {client, backend, session, thread},


   INT size
)

Attempt to reserve size bytes and release the reservation right away. Return the size of the reservation.

See vtc.workspace_alloc() for semantics of the size argument.

INT workspace_free(ENUM {client, backend, session, thread})¶

Find how much unallocated space there is left in a workspace.

VOID workspace_snapshot(ENUM)¶

VOID workspace_snapshot(ENUM {client, backend, session, thread})

Snapshot a workspace. Only one snapshot may be active at a time and each VCL can save only one snapshot, so concurrent tasks requiring snapshots are not supported.

VOID workspace_reset(ENUM)¶

VOID workspace_reset(ENUM {client, backend, session, thread})

Reset to the previous snapshot of a workspace, it must be the same workspace too.

BOOL workspace_overflowed(ENUM)¶

BOOL workspace_overflowed(ENUM {client, backend, session, thread})

Find whether the workspace overflow mark is set or not.

VOID workspace_overflow(ENUM)¶

VOID workspace_overflow(ENUM {client, backend, session, thread})

Mark a workspace as overflowed.

BLOB workspace_dump(ENUM, ENUM, BYTES off, BYTES len)¶

BLOB workspace_dump(


   ENUM {client, backend, session, thread},


   ENUM {s, f, r},


   BYTES off=0,


   BYTES len=64
)

Return data from a workspace's s, f, or r pointer as a blob. Data is copied onto the primary workspace to avoid it being subsequently overwritten.

The maximum len is 1KB.

INT typesize(STRING)¶

Returns the size in bytes of a collection of C-datatypes:

This can be useful for VMOD authors in conjunction with workspace operations.

BLOB proxy_header(ENUM version, IP client, IP server, STRING authority)¶

BLOB proxy_header(


   ENUM {v1, v2} version,


   IP client,


   IP server,


   STRING authority=0
)

Format a proxy header of the given version v1 or v2 and addresses (The VCL IP type also conatins the port number).

Optionally also send an authority TLV with version v2 (ignored for version v1).

Candidate for moving into vmod_proxy, but there were concerns about the interface design